import requests
import json


def get_completion(prompt):
    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer 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',
    }

    data = {
        "model": "deepseek/deepseek-chat-v3-0324:free",
        "prompt": prompt,
    }

    response = requests.post('https://openrouter.ai/api/v1/chat/completions', headers=headers, data=json.dumps(data))

    return response.json()['choices'][0]['message']['content']


if __name__ == '__main__':
    output = get_completion('''system: 你是一个高级软件测试工程师，帮助我生成待测函数的变异规则。
user: 
## Role : 测试用例变异规则生成

## Profile :

- version: 0.1
- description: 我是一名测试用例变异专家，我的职责是分析待测函数的特性，结合已有的大模型生成测试用例种子，根据函数功能、输入类型和边界条件，为种子数据生成适合的多样化变异规则。
我会选择最合适的变异策略，并从语句级、代码块级或函数级别执行变异操作，以生成高覆盖率和高效性的测试数据。

## Task:
- 读取文件数据：每次程序启动时，都会从指定的文件中读取已有的数据（包含原始输入数据和变异数据）。
- 执行变异操作：对每一行数据（即每一组输入数据）执行变异操作，每个参数（如 a 和 b）都会经过多种变异操作，生成多个新的数据对。
- 保存变异结果：程序将新的变异数据追加到文件中，确保下一次运行时，变异数据可以作为输入继续执行变异操作。

## Goals :
- 分析待测函数的特性，根据参数的类型，设计基于其输入输出特性、功能需求及潜在漏洞的变异规则，以提升测试用例的覆盖率。
- 基于模糊测试变异算法设计多样化规则，确保变异数据涵盖功能性、边界条件及异常场景，变异的广度和深度足够，保证变异的灵活性以及覆盖率足够高。
    - 位级别的变异，如：单个位翻转，随机位翻转，字节翻转，插入特殊位模式。
    - 字符级别的变异，如：随机字符替换，插入特殊字符，删除字符。
    - 数值级别的变异，如：溢出值，边界值，随机替换值，加减操作。
    - 结构化变异，如：字段删除，字段替换，字段重复，层级调整，嵌套增加。
    - 综合变异模式，即多种变异模式混合使用。
- 输出变异规则和每条规则的适用场景、变异方式及预期目的。
- 根据测试用例种子生成对应的测试驱动程序代码。测试驱动程序的定义是：一种专用于测试的软件模块。以待测软件和测试要求为输入，能够控制测试的进行。

待测函数代码：

        public static int Mul(int a, float b)
        {
            return (int)(a * b);
        }

待测函数参数示例：
12,56

待变异测试函数代码：

public static void TestMul(int a, float b, int expected)
    {
        int result = Mul(a, b);
        Console.WriteLine($"Test {a} * {b} = {result}, Expected: {expected}");
        if (result == expected)
        {
            Console.WriteLine("Test Passed");
        }
        else
        {
            Console.WriteLine("Test Failed");
        }
    }



任务：请根据待测函数代码和参数示例，生成可运行的驱动函数代码。
要求：
1. 所有引用的变量、方法、类、规则必须显式定义，不允许省略任何代码或注释。
2. 代码必须包含清晰的输入输出说明，完整的测试逻辑，确保直接运行。
3. 提供所有依赖的规则定义和引用代码。
4. 如果逻辑复杂，可通过注释清晰说明生成过程，确保可读性。
5. 确保生成代码包含初始化测试输入、调用目标函数、捕获异常和输出测试结果的完整流程。
6. 在数据为空或格式异常的情况下，应通过合理的异常处理机制保证程序的健壮性，避免因个别数据问题导致变异或写入流程中断，确保数据生成过程的持续性。
7. 若涉及复杂数据类型（如 List<int>、Dictionary<string, double>），需保证main函数中写入的初始数据和后续生成的变异数据符合格式要求，避免出现解析错误或程序崩溃。
例如 List<int> 应以逗号分隔的数值字符串表示，Dictionary<string, double> 应采用 key:value,key:value 形式，避免因解析错误导致数据异常或程序崩溃。
8. 避免使用 '// TODO' 或其他需要人工补全的内容，确保代码完整无遗漏。
9. 涉及字符串处理的操作中，若出现路径，请不要验证路径是否存在于文件系统中，所有变异操作仅作为测试字符串处理使用。
10. 确保在所有可能涉及索引操作的情况下（如 Substring、数组访问等），索引值都在有效范围内，避免 System.ArgumentOutOfRangeException 错误。


格式参考如下：

using System;
using System.IO;
using System.Linq;

public class FuzzTest
{
    // 待测函数
    public static int Add(int a, float b)
    {
        return (int)(a + b);
    }

   // 模糊测试变异算法1：位翻转变异
    public static int BitFlipMutation(int originalInput)
    {
        Random rand = new Random();
        return originalInput ^ (1 << rand.Next(0, 32)); // 位翻转
    }

    // 模糊测试变异算法2：值域扩展（增加/减少一些值）
    public static int RangeExpansionMutation(int originalInput)
    {
        Random rand = new Random();
        return originalInput + rand.Next(-10, 11); // -10 到 10 范围内的变异
    }

    // 模糊测试变异算法3：随机偏移
    public static int RandomOffsetMutation(int originalInput)
    {
        Random rand = new Random();
        return originalInput + rand.Next(-5, 6); // 偏移范围 -5 到 5
    }

    // 模糊测试变异算法4：字节级替换变异
    public static int ByteSubstitutionMutation(int originalInput)
    {
        Random rand = new Random();
        int bytePosition = rand.Next(0, 4); // 选择一个字节 (0-3)
        int newByteValue = rand.Next(0, 256); // 生成一个随机字节 (0-255)

        // 使用位运算替换指定字节
        int mask = 0xFF << (bytePosition * 8);
        return (originalInput & ~mask) | (newByteValue << (bytePosition * 8));
    }

    // 模糊测试变异算法5：综合变异
    public static int CombinedMutation(int originalInput)
    {
        Random rand = new Random();
        int mutatedValue = originalInput;

        // 1. 取反变异
        if (rand.NextDouble() < 0.3) // 30% 概率取反
        {
            mutatedValue = -mutatedValue;
        }

        // 2. 小范围扰动
        if (rand.NextDouble() < 0.5) // 50% 概率加减扰动
        {
            mutatedValue += rand.Next(-10, 10);
        }

        // 3. 边界值测试
        if (rand.NextDouble() < 0.2) // 20% 概率使用边界值
        {
            mutatedValue = (rand.Next(0, 2) == 0) ? int.MaxValue : int.MinValue;
        }

        // 4. 位翻转（随机翻转1-3位）
        if (rand.NextDouble() < 0.4) // 40% 概率翻转位
        {
            int flipCount = rand.Next(1, 4);
            for (int i = 0; i < flipCount; i++)
            {
                mutatedValue ^= (1 << rand.Next(0, 31));
            }
        }

        // 5. 溢出测试
        if (rand.NextDouble() < 0.3) // 30% 概率尝试溢出
        {
            mutatedValue = unchecked(mutatedValue * 2);
        }

        // 6. 随机替换
        if (rand.NextDouble() < 0.1) // 10% 概率完全随机
        {
            mutatedValue = rand.Next(int.MinValue, int.MaxValue);
        }

        return mutatedValue;
    }

    // 遍历所有变异方法并保存结果到文件
    public static void TestAndSaveResults(string filePath)
    {
        // 读取文件中所有现有数据
        var existingEntries = File.ReadAllLines(filePath)
                                  .Where(line => !string.IsNullOrWhiteSpace(line))
                                  .ToList();

        // 创建 StreamWriter 用于文件写入，追加模式
        using (StreamWriter writer = new StreamWriter(filePath, append: true))
        {
            // 遍历已有数据，对每一组数据进行变异
            foreach (var line in existingEntries)
            {
                // 每行数据格式: a,b
                var parts = line.Split(',');
                if (parts.Length < 2)
                    continue; // 如果格式不正确，跳过

                int a = int.Parse(parts[0]);
                float b = float.Parse(parts[1]);

                // 进行变异操作
                int mutatedA1 = BitFlipMutation(a);
                int mutatedA2 = RangeExpansionMutation(a);
                int mutatedA3 = RandomOffsetMutation(a);

                int mutatedB1 = BitFlipMutation((int)b);
                int mutatedB2 = RangeExpansionMutation((int)b);
                int mutatedB3 = RandomOffsetMutation((int)b);

                // 记录原始数据
                writer.WriteLine($"{a},{b}");

                // 记录变异数据
                writer.WriteLine($"{mutatedA1},{mutatedB1}");
                writer.WriteLine($"{mutatedA2},{mutatedB2}");
                writer.WriteLine($"{mutatedA3},{mutatedB3}");
            }
        }
    }

    public static void Main(string[] args)
    {
        string filePath = "test_results.txt"; // 文件路径，这里固定为 test_results.txt

        // 如果文件存在，删除它
        if (File.Exists(filePath))
        {
            File.Delete(filePath);
        }

        // 创建新文件并写入初始数据
        using (StreamWriter writer = new StreamWriter(filePath))
        {
            writer.WriteLine("5,3");       // 初始数据
        }

        // 循环多次，持续读取和生成新数据
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"Iteration {i + 1}: Processing data...");
            TestAndSaveResults(filePath);

            // 从文件读取数据并运行待测函数
            var entries = File.ReadAllLines(filePath)
                              .Where(line => !string.IsNullOrWhiteSpace(line))
                              .ToList();

            foreach (var line in entries)
            {
                var parts = line.Split(',');
                if (parts.Length < 2)
                    continue; // 跳过格式错误的行

                int a = int.Parse(parts[0]);
                float b = float.Parse(parts[1]);

                try
                {
                    int result = Add(a, b);
                    //Console.WriteLine($"({a}, {b})");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error processing {a},{b}: {ex.Message}");
                }
            }
        }

        // 提示用户完成
        Console.WriteLine("All iterations completed and results saved to file.");
    }
}
''')
    with open("output.txt", "w", encoding="utf-8") as file:
        file.write(output)
    print("输出已保存到 output.txt 文件中。")